﻿//===========================================================================================================================
// Cuberry - http://www.cuberry.net
// Copyright (c) 2012
// by Peacequare® - Amir Moussa
//===========================================================================================================================
// This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License 
// as published by the Free Software Foundation, either version 3 of the License, or any later version.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated 
// documentation files (the "Software"), to deal in the Software without restriction, including without limitation 
// the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and 
// to permit persons to whom the Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or substantial portions 
// of the Software.
//
// This program is distributed in the hope that it will be useful.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF 
// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
// DEALINGS IN THE SOFTWARE.
//
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//===========================================================================================================================

using System;
using System.Collections.Generic;
using System.ComponentModel;
using Microsoft.Practices.Prism.Events;
using Microsoft.Practices.Prism.Commands;
using P2.Cuberry.Framework.Helper;
using Microsoft.Practices.Unity;
using Microsoft.Practices.Prism.Regions;
using System.Windows;


namespace P2.Cuberry.Modules.SimpleAccounting.FiTransaction
{
    class FiTransactionsFindPresenter : IFiTransactionsFindPresenter, INotifyPropertyChanged
    {

        public FiTransactionsFindPresenter(IFiTransactionsFindView view, Services.IFiTransactionService service,
            IUnityContainer container, IRegionManager regionManager)
        {
            try
            {
                View = view;
                this.container = container;
                this.regionManager = regionManager;
                
                this.Model = new BusinessEntities.FiTransactionQuery();
                this.Service = service;
                this.FiscalYears = P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiFiscalYear.GetList;
                WorkflowStatusses = P2.Cuberry.Framework.Helper.Workflows.WorkflowStatus.GetStatusListForObject(Model.EntityName);

                this.FiTransactionAddCommand = new DelegateCommand<object>(OnFiTransactionAddExecute, OnFiTransactionAddCanExecute);
                this.FiTransactionFindCommand = new DelegateCommand<object>(OnFiTransactionFindExecute, OnFiTransactionFindCanExecute);
                this.FiTransactionClrCommand = new DelegateCommand<object>(OnFiTransactionClrExecute, OnFiTransactionClrCanExecute);
                this.FiTransactionFindAccountCommand = new DelegateCommand<object>(OnFiTransactionFindAccountExecute, OnFiTransactionFindAccountCanExecute);
                this.FiTransactionFindAccountTreeCommand = new DelegateCommand<object>(OnFiTransactionFindAccountTreeExecute, OnFiTransactionFindAccountTreeCanExecute);

                if (this.FiscalYears.Count > 0)
                    Model.FiscalYearID = this.FiscalYears[0].FiscalYearID;
                else
                    Model.FiscalYearID = -1;
                ControlRights = Model.GetControls(Properties.Settings.Default.ModuleName, "FiTransactionsFindView");

                View.Presenter = this;
            }
            catch (System.Exception ex) //AM:TC
            {
                P2ExceptionHandler.LogException(ex, string.Format("{0}.{1}", this.GetType().Name, System.Reflection.MethodInfo.GetCurrentMethod().Name));
            }
        }


        #region "Members"

        public int? BookingID
        {
            get { return Model.BookingID; }
            set
            {
                if (Model.BookingID != value)
                {
                    Model.BookingID = value;
                    OnPropertyChanged("BookingID");
                }
            }
        }


        public string DocumentNo
        {
            get { return Model.DocumentNo; }
            set
            {
                if (Model.DocumentNo != value)
                {
                    Model.DocumentNo = value;
                    OnPropertyChanged("DocumentNo");
                }
            }
        }


        public int FiscalYearID
        {
            get { return Model.FiscalYearID; }
            set
            {
                if (Model.FiscalYearID != value)
                {
                    Model.FiscalYearID = value;
                    OnPropertyChanged("FiscalYearID");
                }
            }
        }


        public decimal? TotalAmountStart
        {
            get { return Model.TotalAmountStart; }
            set
            {
                if (Model.TotalAmountStart != value)
                {
                    Model.TotalAmountStart = value;
                    OnPropertyChanged("TotalAmountStart");
                }
            }
        }

        public decimal? TotalAmountEnd
        {
            get { return Model.TotalAmountEnd; }
            set
            {
                if (Model.TotalAmountEnd != value)
                {
                    Model.TotalAmountEnd = value;
                    OnPropertyChanged("TotalAmountEnd");
                }
            }
        }

        public string BookingDescription
        {
            get { return Model.BookingDescription; }
            set
            {
                if (Model.BookingDescription != value)
                {
                    Model.BookingDescription = value;
                    OnPropertyChanged("BookingDescription");
                }
            }
        }


        public DateTime? BookingDateStart
        {
            get { return Model.BookingDateStart; }
            set
            {
                if (Model.BookingDateStart != value)
                {
                    Model.BookingDateStart = value;
                    OnPropertyChanged("BookingDateStart");
                }
            }
        }


        public DateTime? BookingDateEnd
        {
            get { return Model.BookingDateEnd; }
            set
            {
                if (Model.BookingDateEnd != value)
                {
                    Model.BookingDateEnd = value;
                    OnPropertyChanged("BookingDateEnd");
                }
            }
        }
        
        public int? FiAccountID
        {
            get { return Model.AccountID; }
            set
            {
                if (Model.AccountID != value)
                {
                    Model.AccountID = value;
                    OnPropertyChanged("FiAccountID");
                    OnPropertyChanged("FiAccountNo");
                    _fiTransactionItemAccount = null;
                }
            }
        }
        protected P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiAccount _fiTransactionItemAccount;
        protected P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiAccount FiTransactionItemAccount
        {
            get
            {
                if (_fiTransactionItemAccount == null || _fiTransactionItemAccount.FiAccountID != this.FiAccountID)
                    _fiTransactionItemAccount = new P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiAccount(this.FiAccountID.GetValueOrDefault(-1));
                return _fiTransactionItemAccount;
            }
        }


        public string FiAccountNo
        {
            get
            {
                return this.FiTransactionItemAccount.FiAccountNo;
            }
            set
            {
                var tempAccount = P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiAccount.GetFiAccountByAccountNo(value, this.FiscalYearID);
                _fiTransactionItemAccount = tempAccount;
                if (tempAccount != null && tempAccount.IsActive && tempAccount.Chargeable.GetValueOrDefault(false))
                {
                    FiAccountID = tempAccount.FiAccountID;
                }
                else
                {
                    FiAccountID = null;
                }
                OnPropertyChanged("FiAccountID");
                OnPropertyChanged("FiAccountNo");

            }
        }

        public int StatusID
        {
            get { return Model.StatusID; }
            set
            {
                if (Model.StatusID != value)
                {
                    Model.StatusID = value;
                    OnPropertyChanged("StatusID");
                }
            }
        }
        
        #endregion


        #region "Reference Tables"

        public List<P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiFiscalYear> FiscalYears { get; set; }
        public List<P2.Cuberry.Framework.Helper.Workflows.WorkflowStatus> WorkflowStatusses { get; set; }
        
        #endregion


        #region Commands

        public DelegateCommand<object> FiTransactionAddCommand { get; set; }
        public DelegateCommand<object> FiTransactionClrCommand { get; set; }
        public DelegateCommand<object> FiTransactionFindCommand { get; set; }
        public DelegateCommand<object> FiTransactionFindAccountCommand { get; set; }
        public DelegateCommand<object> FiTransactionFindAccountTreeCommand { get; set; }   

        void OnFiTransactionAddExecute(object sourceAccount)
        {
            try
            {
                BusinessEntities.FiTransactionHeader fiTransaction = new BusinessEntities.FiTransactionHeader();
                if (this.Model.FiscalYear != null && this.Model.FiscalYear.StatusID != 173102)
                {
                    View.DisplayError(P2Translator.GetResource("TMsg_FiscalYearStatusError"), P2Translator.GetResource("TMsg_ErrorCaption"));
                    return;
                }
                fiTransaction.FiscalYearID = this.FiscalYearID;
                if (FiTransactionAdd != null)
                {
                    if (FiTransactionAdd != null)
                        FiTransactionAdd(null, new DataEventArgs<BusinessEntities.FiTransactionHeader>(fiTransaction));

                }
            }
            catch (System.Exception ex) //AM:TC
            {
                P2ExceptionHandler.LogException(ex, string.Format("{0}.{1}", this.GetType().Name, System.Reflection.MethodInfo.GetCurrentMethod().Name));
            }
        }


        bool OnFiTransactionAddCanExecute(object sourceAccount)
        {
            try
            {
                P2.Cuberry.Framework.Security.User.ControlRight controlRight;
                if (ControlRights.TryGetValue("FiTransactionAddBtn", out controlRight))
                    return controlRight.IsActive;
                else
                    return false;
            }
            catch (System.Exception ex) //AM:TC
            {
                P2ExceptionHandler.LogException(ex, string.Format("{0}.{1}", this.GetType().Name, System.Reflection.MethodInfo.GetCurrentMethod().Name));
                return false;
            }
        }


        void OnFiTransactionFindExecute(object sourceAccount)
        {
            this.View.UpdateFocusedControl();
            if (FiTransactionFind != null)
                FiTransactionFind(null, new DataEventArgs<BusinessEntities.FiTransactionQuery>(this.Model));
        }


        bool OnFiTransactionFindCanExecute(object sourceAccount)
        {
            return true;
        }


        void OnFiTransactionClrExecute(object sourceAccount)
        {
            try
            {
                this.DocumentNo = "";
                this.BookingDescription = "";
                this.TotalAmountStart = null;
                this.TotalAmountEnd = null;
                this.FiAccountID = null;

                if (this.FiscalYears.Count > 0)
                    this.FiscalYearID = FiscalYears[0].FiscalYearID;
                else
                    this.FiscalYearID = 0;
                this.BookingID = null;
                BookingDateStart = null;
                BookingDateEnd = null;
                StatusID = -1;
                OnPropertyChanged("BookingID");
            }
            catch (System.Exception ex) //AM:TC
            {
                P2ExceptionHandler.LogException(ex, string.Format("{0}.{1}", this.GetType().Name, System.Reflection.MethodInfo.GetCurrentMethod().Name));
            }
        }


        bool OnFiTransactionClrCanExecute(object sourceAccount)
        {
            return true;
        }

        void OnFiTransactionFindAccountExecute(object sourceAccount)
        {
            try
            {
                View.UpdateFocusedControl();

                IFiTransactionsFindAccountView findAccountView = this.container.Resolve<IFiTransactionsFindAccountView>();
                FiTransactionFindAccountPresentationModel pm;
                P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiAccount templateAccount = new P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiAccount();
                templateAccount.FiAccountFiscalYearID = this.FiscalYearID;
                templateAccount.Chargeable = true;
                List<P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiAccount> allAccounts = Service.RetrieveFiAccounts(templateAccount);

                pm = new FiTransactionFindAccountPresentationModel(findAccountView, this.Service, allAccounts, this.container, this.regionManager, this.Model.FiscalYearID);

                findAccountView.FlowDirection = (P2Translator.Culture.TextInfo.IsRightToLeft ? FlowDirection.RightToLeft : FlowDirection.LeftToRight);
                bool? editResult = findAccountView.ShowDialog();
                if (editResult.HasValue && editResult.Value)
                {
                    if (pm.FiAccountID > 0)
                        this.FiAccountID = pm.FiAccountID;
                    return;
                }
            }
            catch (System.Exception ex) //AM:TC
            {
                P2ExceptionHandler.LogException(ex, string.Format("{0}.{1}", this.GetType().Name, System.Reflection.MethodInfo.GetCurrentMethod().Name));
            }

        }

        bool OnFiTransactionFindAccountCanExecute(object sourceAccount)
        {
            return true;
        }


        void OnFiTransactionFindAccountTreeExecute(object sourceAccount)
        {
            try
            {
                View.UpdateFocusedControl();

                P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiAccount templateAccount = new P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiAccount();
                templateAccount.FiAccountFiscalYearID = this.FiscalYearID;
                templateAccount.Chargeable = true;
                List<P2.Cuberry.Modules.SimpleAccounting.FiAccount.BusinessEntities.FiAccount> allAccounts = Service.RetrieveFiAccounts(templateAccount);


                IFiTransactionsFindAccountTreeView findAccountView = this.container.Resolve<IFiTransactionsFindAccountTreeView>();
                FiTransactionFindAccountTreeViewPresentationModel pm;

                pm = new FiTransactionFindAccountTreeViewPresentationModel(findAccountView, this.Service, allAccounts, this.container, this.regionManager, this.Model.FiscalYearID);

                findAccountView.FlowDirection = (P2Translator.Culture.TextInfo.IsRightToLeft ? FlowDirection.RightToLeft : FlowDirection.LeftToRight);
                bool? editResult = findAccountView.ShowDialog();
                if (editResult.HasValue && editResult.Value)
                {
                    if (pm.FiAccountID > 0)
                        this.FiAccountID = pm.FiAccountID;
                    return;
                }
            }
            catch (System.Exception ex) //AM:TC
            {
                P2ExceptionHandler.LogException(ex, string.Format("{0}.{1}", this.GetType().Name, System.Reflection.MethodInfo.GetCurrentMethod().Name));
            }
        }

        bool OnFiTransactionFindAccountTreeCanExecute(object sourceAccount)
        {
            return true;
        }



        #endregion

        private IUnityContainer container;
        private IRegionManager regionManager;

        public IFiTransactionsFindView View { get; set; }
        public Services.IFiTransactionService Service;
        public BusinessEntities.FiTransactionQuery Model { get; set; }

        public Dictionary<string, P2.Cuberry.Framework.Security.User.ControlRight> ControlRights;

        public P2MessageStack MessageStack = new P2MessageStack();

        public event EventHandler<DataEventArgs<BusinessEntities.FiTransactionQuery>> FiTransactionFind = delegate { };
        public event EventHandler<DataEventArgs<BusinessEntities.FiTransactionHeader>> FiTransactionAdd = delegate { };


        #region Property Changed

        public event PropertyChangedEventHandler PropertyChanged;

        private void OnPropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler Handler = PropertyChanged;
            if (Handler != null) Handler(this, new PropertyChangedEventArgs(propertyName));
        }

        #endregion

    }
}
